{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Discover and Transformation\n",
    "in this section of the lab, we'll use Glue to discover new transportation data.  From there, we'll use Athena to query and start looking into the dataset to understand the data we are dealing with.\n",
    "\n",
    "We've also setup a set of ETLs using Glue to create the fields into a canonical form, since all the fields call names different things.  \n",
    "\n",
    "After understanding the data, and cleaning it a little, we'll go into another notebook to perform feature engineering and time series modeling."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are Databases and Tables in Glue:\n",
    "When you define a table in the AWS Glue Data Catalog, you add it to a database. A database is used to organize tables in AWS Glue. You can organize your tables using a crawler or using the AWS Glue console. A table can be in only one database at a time.\n",
    "\n",
    "Your database can contain tables that define data from many different data stores.\n",
    "\n",
    "A table in the AWS Glue Data Catalog is the metadata definition that represents the data in a data store. You create tables when you run a crawler, or you can create a table manually in the AWS Glue console. The Tables list in the AWS Glue console displays values of your table's metadata. You use table definitions to specify sources and targets when you create ETL (extract, transform, and load) jobs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import boto3\n",
    "\n",
    "database_name = '2019reinventWorkshop'\n",
    "\n",
    "## lets first create a namespace for the tables:\n",
    "glue_client = boto3.client('glue')\n",
    "create_database_resp = glue_client.create_database(\n",
    "    DatabaseInput={\n",
    "        'Name': database_name,\n",
    "        'Description': 'This database will contain the tables discovered through both crawling and the ETL processes'\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will create a new database, or namespace, that can hold the collection of tables\n",
    "\n",
    "https://console.aws.amazon.com/glue/home?region=us-east-1#catalog:tab=databases\n",
    "\n",
    "![create db response](images/createdatabaseresponse.png \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use a crawler to populate the AWS Glue Data Catalog with tables. This is the primary method used by most AWS Glue users. A crawler can crawl multiple data stores in a single run. Upon completion, the crawler creates or updates one or more tables in your Data Catalog. Extract, transform, and load (ETL) jobs that you define in AWS Glue use these Data Catalog tables as sources and targets. The ETL job reads from and writes to the data stores that are specified in the source and target Data Catalog tables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "crawler_name = '2019reinventworkshopcrawler'\n",
    "create_crawler_resp = glue_client.create_crawler(\n",
    "    Name=crawler_name,\n",
    "    Role='GlueRole',\n",
    "    DatabaseName=database_name,\n",
    "    Description='Crawler to discover the base tables for the workshop',\n",
    "    Targets={\n",
    "        'S3Targets': [\n",
    "            {\n",
    "                'Path': 's3://serverless-analytics/reinvent-2019/taxi_data/',\n",
    "            },\n",
    "        ]\n",
    "    }\n",
    ")\n",
    "response = glue_client.start_crawler(\n",
    "    Name=crawler_name\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After starting the crawler, you can go to the glue console if you'd like to see it running.\n",
    "\n",
    "https://console.aws.amazon.com/glue/home?region=us-east-1#catalog:tab=crawlers\n",
    "![startcrawlerui](images/startcrawlerui.png \"\")\n",
    "\n",
    "After it finishes crawling, you can see the datasets (represeted as \"tables\") it automatically discovered.\n",
    "![crawler_discovered](images/crawler_discovered.png \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Waiting for the Crawler to finish"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUNNING\n",
      "RUNNING\n",
      "STOPPING\n",
      "STOPPING\n",
      "finished running READY\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    " \n",
    "response = glue_client.get_crawler(\n",
    "    Name=crawler_name\n",
    ")\n",
    "while (response['Crawler']['State'] == 'RUNNING') | (response['Crawler']['State'] == 'STOPPING'):\n",
    "    print(response['Crawler']['State'])\n",
    "    # Wait for 40 seconds\n",
    "    time.sleep(40)\n",
    "    \n",
    "    response = glue_client.get_crawler(\n",
    "        Name=crawler_name\n",
    "    )\n",
    "\n",
    "print('finished running', response['Crawler']['State'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Querying the data\n",
    "\n",
    "We'll use Athena to query the data.  Athena allows us to perform SQL queries against datasets on S3, without having to transform them, load them into a traditional sql datastore, and allows rapid ad-hoc investigation.  \n",
    "\n",
    "Later we'll use Spark to do ETL and feature engineering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install --upgrade pip > /dev/null\n",
    "!pip install PyAthena > /dev/null"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Athena uses S3 to store results to allow different types of clients to read it and so you can go back and see the results of previous queries.  We can set that up next:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sagemaker\n",
    "sagemaker_session = sagemaker.Session()\n",
    "athena_data_bucket = sagemaker_session.default_bucket()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we'll create an Athena connection we can use, much like a standard JDBC/ODBC connection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     type  ride_count\n",
      "0   green    12105351\n",
      "1  yellow   147263398\n",
      "2     fhv   292722358\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa3420bbeb8>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pyathena import connect\n",
    "import pandas as pd\n",
    "\n",
    "sagemaker_session = sagemaker.Session()\n",
    "\n",
    "conn = connect(s3_staging_dir=\"s3://\" + athena_data_bucket,\n",
    "               region_name=sagemaker_session.boto_region_name)\n",
    "\n",
    "df = pd.read_sql('SELECT \\'yellow\\' type, count(*) ride_count FROM \"' + database_name + '\".\"yellow\" ' + \n",
    "                 'UNION ALL SELECT \\'green\\' type, count(*) ride_count FROM \"' + database_name + '\".\"green\"' +\n",
    "                 'UNION ALL SELECT \\'fhv\\' type, count(*) ride_count FROM \"' + database_name + '\".\"fhv\"', conn)\n",
    "print(df)\n",
    "df.plot.bar(x='type', y='ride_count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "response from starting green\n",
      "{'JobRunId': 'jr_466ee6fbc9356bdaf875f815035e823c382666cc060e38092fe91d5411ae0546', 'ResponseMetadata': {'RequestId': 'bf2b5ed1-2b2b-11ea-9cf9-c754cb1c941b', 'HTTPStatusCode': 200, 'HTTPHeaders': {'date': 'Mon, 30 Dec 2019 17:42:28 GMT', 'content-type': 'application/x-amz-json-1.1', 'content-length': '82', 'connection': 'keep-alive', 'x-amzn-requestid': 'bf2b5ed1-2b2b-11ea-9cf9-c754cb1c941b'}, 'RetryAttempts': 0}}\n"
     ]
    }
   ],
   "source": [
    "green_etl = '2019reinvent_green'\n",
    "\n",
    "response = glue_client.start_job_run(\n",
    "    JobName=green_etl,\n",
    "    WorkerType='Standard', # other options include: 'G.1X'|'G.2X',\n",
    "    NumberOfWorkers=5\n",
    ")\n",
    "print('response from starting green')\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After kicking it off, you can see it running in the console too:\n",
    "https://console.aws.amazon.com/glue/home?region=us-east-1#etl:tab=jobs\n",
    "<img src=\"images/ETLStart.png\"/>\n",
    "\n",
    "<b>WAIT UNTIL THE ETL JOB FINISHES BEFORE CONTINUING!</b>\n",
    "<b>ALSO, YOU MUST CHANGE THE BUCKET PATH IN THIS CELL - FIND THE BUCKET IN S3 THAT CONTAINS '2019reinventetlbucket' in the name</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-12-30 17:08:43 aim357-template2-2019reinventetlbucket-144yyhe1x8qgo\n"
     ]
    }
   ],
   "source": [
    "#let's list the s3 bucket name:\n",
    "!aws s3 ls | grep '2019reinventetlbucket' | head -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# syntax should be s3://...\n",
    "normalized_bucket = 's3://aim357-template2-2019reinventetlbucket-144yyhe1x8qgo'\n",
    "\n",
    "\n",
    "\n",
    "## DO NOT MODIFY THESE LINES, they are there to ensure the line above is updated correctly\n",
    "assert(normalized_bucket != 's3://FILL_IN_BUCKET_NAME')\n",
    "assert(normalized_bucket.startswith( 's3://' ))\n",
    "\n",
    "create_crawler_resp = glue_client.create_crawler(\n",
    "    Name=crawler_name + '_normalized',\n",
    "    Role='GlueRole',\n",
    "    DatabaseName=database_name,\n",
    "    Description='Crawler to discover the base tables for the workshop',\n",
    "    Targets={\n",
    "        'S3Targets': [\n",
    "            {\n",
    "                'Path': normalized_bucket + \"/canonical/\",\n",
    "            },\n",
    "        ]\n",
    "    }\n",
    ")\n",
    "response = glue_client.start_crawler(\n",
    "    Name=crawler_name + '_normalized'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's wait for the next crawler to finish, this will discover the normalized dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUNNING\n",
      "STOPPING\n",
      "STOPPING\n",
      "finished running READY\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    " \n",
    "response = glue_client.get_crawler(\n",
    "    Name=crawler_name + '_normalized'\n",
    ")\n",
    "while (response['Crawler']['State'] == 'RUNNING') | (response['Crawler']['State'] == 'STOPPING'):\n",
    "    print(response['Crawler']['State'])\n",
    "    # Wait for 40 seconds\n",
    "    time.sleep(40)\n",
    "    \n",
    "    response = glue_client.get_crawler(\n",
    "        Name=crawler_name + '_normalized'\n",
    "    )\n",
    "\n",
    "print('finished running', response['Crawler']['State'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Querying the Normalized Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at the total counts for the aggregated information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    type  ride_count\n",
      "0  green    12105351\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa341e78c18>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "normalized_df = pd.read_sql('SELECT type, count(*) ride_count FROM \"' + database_name + '\".\"canonical\" group by type', conn)\n",
    "print(normalized_df)\n",
    "normalized_df.plot.bar(x='type', y='ride_count')\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa3422d5278>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "query = \"select type, date_trunc('day', pickup_datetime) date, count(*) cnt from \\\"\" + database_name + \"\\\".canonical where pickup_datetime < timestamp '2099-12-31' group by type, date_trunc(\\'day\\', pickup_datetime) \"\n",
    "typeperday_df = pd.read_sql(query, conn)\n",
    "typeperday_df.plot(x='date', y='cnt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We see some bad data here...\n",
    "We are expecting only 2018 and 2019 datasets here, but can see there are records far into the future and in the past.  This represents bad data that we want to eliminate before we build our model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setting index to date\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>type</th>\n",
       "      <th>cnt</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-03-18</th>\n",
       "      <td>green</td>\n",
       "      <td>25602</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-01</th>\n",
       "      <td>green</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-06-07</th>\n",
       "      <td>green</td>\n",
       "      <td>25159</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-06-28</th>\n",
       "      <td>green</td>\n",
       "      <td>24517</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-06-21</th>\n",
       "      <td>green</td>\n",
       "      <td>25620</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             type    cnt\n",
       "date                    \n",
       "2018-03-18  green  25602\n",
       "2019-07-01  green     15\n",
       "2018-06-07  green  25159\n",
       "2018-06-28  green  24517\n",
       "2018-06-21  green  25620"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Only reason we put this conditional here is so you can execute the cell multiple times\n",
    "# if you don't check, it won't find the 'date' column again and makes interacting w/ the notebook more seemless\n",
    "if type(typeperday_df.index) != pd.core.indexes.datetimes.DatetimeIndex:\n",
    "    print('setting index to date')\n",
    "    typeperday_df = typeperday_df.set_index('date', drop=True)\n",
    "    \n",
    "typeperday_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa3422680b8>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "typeperday_df.loc['2018-01-01':'2019-12-31'].plot(y='cnt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at some of the bad data now:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the bad data, at least the bad data in the future, is coming from the yellow taxi license type.\n",
    "\n",
    "### Note, we are querying the transformed data.\n",
    "\n",
    "We should check the raw dataset to see if it's also bad or something happened in the ETL process\n",
    "\n",
    "Let's find the two 2088 records to make sure they are in the source data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>vendorid</th>\n",
       "      <th>tpep_pickup_datetime</th>\n",
       "      <th>tpep_dropoff_datetime</th>\n",
       "      <th>passenger_count</th>\n",
       "      <th>trip_distance</th>\n",
       "      <th>ratecodeid</th>\n",
       "      <th>store_and_fwd_flag</th>\n",
       "      <th>pulocationid</th>\n",
       "      <th>dolocationid</th>\n",
       "      <th>payment_type</th>\n",
       "      <th>fare_amount</th>\n",
       "      <th>extra</th>\n",
       "      <th>mta_tax</th>\n",
       "      <th>tip_amount</th>\n",
       "      <th>tolls_amount</th>\n",
       "      <th>improvement_surcharge</th>\n",
       "      <th>total_amount</th>\n",
       "      <th>congestion_surcharge</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>2088-01-24 00:15:42</td>\n",
       "      <td>2088-01-24 00:19:46</td>\n",
       "      <td>1</td>\n",
       "      <td>0.63</td>\n",
       "      <td>1</td>\n",
       "      <td>N</td>\n",
       "      <td>41</td>\n",
       "      <td>166</td>\n",
       "      <td>2</td>\n",
       "      <td>4.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.3</td>\n",
       "      <td>5.3</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>2088-01-24 00:25:39</td>\n",
       "      <td>2088-01-24 07:28:25</td>\n",
       "      <td>1</td>\n",
       "      <td>4.05</td>\n",
       "      <td>1</td>\n",
       "      <td>N</td>\n",
       "      <td>24</td>\n",
       "      <td>162</td>\n",
       "      <td>2</td>\n",
       "      <td>14.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.3</td>\n",
       "      <td>15.3</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   vendorid tpep_pickup_datetime tpep_dropoff_datetime  passenger_count  \\\n",
       "0         2  2088-01-24 00:15:42   2088-01-24 00:19:46                1   \n",
       "1         2  2088-01-24 00:25:39   2088-01-24 07:28:25                1   \n",
       "\n",
       "   trip_distance  ratecodeid store_and_fwd_flag  pulocationid  dolocationid  \\\n",
       "0           0.63           1                  N            41           166   \n",
       "1           4.05           1                  N            24           162   \n",
       "\n",
       "   payment_type  fare_amount  extra  mta_tax  tip_amount  tolls_amount  \\\n",
       "0             2          4.5    0.0      0.5         0.0           0.0   \n",
       "1             2         14.5    0.0      0.5         0.0           0.0   \n",
       "\n",
       "   improvement_surcharge  total_amount congestion_surcharge  \n",
       "0                    0.3           5.3                 None  \n",
       "1                    0.3          15.3                 None  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.read_sql(\"select * from \\\"\" + database_name + \"\\\".yellow where tpep_pickup_datetime like '2088%'\", conn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa33e065828>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Next let's plot this per type:\n",
    "typeperday_df.loc['2018-01-01':'2019-07-30'].pivot_table(index='date', \n",
    "                                                         columns='type', \n",
    "                                                         values='cnt', \n",
    "                                                         aggfunc='sum').plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fixing our Time Series data\n",
    "\n",
    "Some details of what caused this drop:\n",
    "#### On August 14, 2018, Mayor de Blasio signed Local Law 149 of 2018, creating a new license category for TLC-licensed FHV businesses that currently dispatch or plan to dispatch more than 10,000 FHV trips in New York City per day under a single brand, trade, or operating name, referred to as High-Volume For-Hire Services (HVFHS). This law went into effect on Feb 1, 2019\n",
    "\n",
    "Let's bring the other license type and see how it affects the time series charts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "create_crawler_resp = glue_client.create_crawler(\n",
    "    Name=crawler_name + '_fhvhv',\n",
    "    Role='GlueRole',\n",
    "    DatabaseName=database_name,\n",
    "    Description='Crawler to discover the base tables for the workshop',\n",
    "    Targets={\n",
    "        'S3Targets': [\n",
    "            {\n",
    "                'Path': 's3://serverless-analytics/reinvent-2019_moredata/taxi_data/fhvhv/',\n",
    "            },\n",
    "        ]\n",
    "    }\n",
    ")\n",
    "response = glue_client.start_crawler(\n",
    "    Name=crawler_name + '_fhvhv'\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wait to discover the fhvhv dataset..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUNNING\n",
      "RUNNING\n",
      "STOPPING\n",
      "STOPPING\n",
      "STOPPING\n",
      "STOPPING\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    " \n",
    "response = glue_client.get_crawler(\n",
    "    Name=crawler_name + '_fhvhv'\n",
    ")\n",
    "while (response['Crawler']['State'] == 'RUNNING') | (response['Crawler']['State'] == 'STOPPING'):\n",
    "    print(response['Crawler']['State'])\n",
    "    # Wait for 40 seconds\n",
    "    time.sleep(40)\n",
    "    \n",
    "    response = glue_client.get_crawler(\n",
    "        Name=crawler_name + '_fhvhv'\n",
    "    )\n",
    "\n",
    "print('finished running', response['Crawler']['State'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "query = 'select \\'fhvhv\\' as type, date_trunc(\\'day\\', cast(pickup_datetime as timestamp)) date, count(*) cnt from \"' + database_name + '\".\"fhvhv\" group by date_trunc(\\'day\\',  cast(pickup_datetime as timestamp)) '\n",
    "typeperday_fhvhv_df = pd.read_sql(query, conn)\n",
    "typeperday_fhvhv_df = typeperday_fhvhv_df.set_index('date', drop=True)\n",
    "print(typeperday_fhvhv_df.head())\n",
    "typeperday_fhvhv_df.plot(y='cnt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([typeperday_fhvhv_df, typeperday_df], sort=False).loc['2018-01-01':'2019-07-30'].pivot_table(index='date', \n",
    "                                                         columns='type', \n",
    "                                                         values='cnt', \n",
    "                                                         aggfunc='sum').plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### That looks better -- let's start looking at performing EDA now. Please open the other notebook file in your SageMaker notebook instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_python3",
   "language": "python",
   "name": "conda_python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
